#
# POCO build script
#
# Usage:
# ------
# buildwin.ps1 [-poco_base    dir]
#              [-vs           140 | 150 | 160| 170]
#              [-action       build | rebuild | clean]
#              [-linkmode     shared | static_mt | static_md | all]
#              [-config       release | debug | both]
#              [-platform     Win32 | x64 | WinCE | WEC2013]
#              [-samples]
#              [-tests]
#              [-omit         "Lib1X;LibY;LibZ;..."]
#              [-tool         msbuild | devenv]
#              [-useenv       env | noenv]
#              [-verbosity    m[inimal] | q[uiet] | n[ormal] | d[etailed] | diag[nostic]]
#              [-openssl_base dir]
#              [-mysql_base   dir]

[CmdletBinding()]
Param
(
	[Parameter()]
	[string] $poco_base,

	[Parameter()]
	[ValidateSet(140, 150, 160, 170)]
	[int] $vs = 140,

	[Parameter()]
	[ValidateSet('build', 'rebuild', 'clean')]
	[string] $action = 'build',

	[Parameter()]
	[ValidateSet('shared', 'static_mt', 'static_md', 'all')]
	[string] $linkmode = 'shared',

	[Parameter()]
	[ValidateSet('release', 'debug', 'both')]
	[string] $config = 'release',

	[Parameter()]
	[ValidateSet('Win32', 'x64', 'WinCE', 'WEC2013')]
	[string] $platform = 'x64',

	[switch] $tests = $false,
	[switch] $samples = $false,
	[string] $omit,

	[Parameter()]
	[ValidateSet('msbuild', 'devenv')]
	[string] $tool = 'msbuild',

	[Parameter()]
	[ValidateSet('env', 'noenv')]
	[string] $useenv = 'env',

	[Parameter()]
	[ValidateSet('quiet', 'm[inimal]', 'n[ormal]', 'd[etailed]', 'diag[nostic]')]
	[string] $verbosity = 'minimal',

	[Parameter()]
	[string] $openssl_base,

	[Parameter()]
	[string] $mysql_base,

	[switch] $help
)

function Add-VSCOMNTOOLS([int] $vsver)
{
  if ($vsver -ge 150)
	{
		$vssetup= $([Environment]::GetFolderPath("MyDocuments"))
		$vssetup= Join-Path $vssetup "WindowsPowerShell"
		$vssetup= Join-Path $vssetup "Modules"
		$vssetup= Join-Path $vssetup "VSSetup"
		if (-not (Test-Path $vssetup))
		{
			Install-Module VSSetup -Scope CurrentUser -Force
		}
		if ($vsver -eq 150)
		{
			$range='[15.0,16.0)'
		}
		if ($vsver -eq 160)
		{
			$range='[16.0,17.0)'
		}
		if ($vsver -eq 170)
		{
			$range='[17.0,18.0)'
		}
		
		$installationPath = Get-VSSetupInstance | Select-VSSetupInstance -Version $range -Latest -Require Microsoft.VisualStudio.Component.VC.Tools.x86.x64 | select InstallationPath
		$vscomntools = $installationPath.psobject.properties.Value;
		if ($vsver -eq 150)
		{
			set-item -force -path "ENV:VS150COMNTOOLS"  -value "$vscomntools\Common7\Tools\"
			Write-Host "`nVS150COMNTOOLS=$env:VS150COMNTOOLS" -ForegroundColor Yellow
		}
		if ($vsver -eq 160)
		{
			set-item -force -path "ENV:VS160COMNTOOLS"  -value "$vscomntools\Common7\Tools\"
			Write-Host "`nVS160COMNTOOLS=$env:VS160COMNTOOLS" -ForegroundColor Yellow
		}
		if ($vsver -eq 170)
		{
			set-item -force -path "ENV:VS170COMNTOOLS"  -value "$vscomntools\Common7\Tools\"
			Write-Host "`nVS170COMNTOOLS=$env:VS170COMNTOOLS" -ForegroundColor Yellow
		}
	}
}

function Add-Env-Var([string] $lib, [string] $var)
{
	if ((${Env:$var} -eq $null) -or (-not ${Env:$var}.Contains(${Env:$lib_$var"})))
	{
		$libvar = "$lib" + "_" + "$var"
		$envvar = [Environment]::GetEnvironmentVariable($var, "Process")
		$envvar = $envvar + ';' + [Environment]::GetEnvironmentVariable($libvar, "Process")
		[Environment]::SetEnvironmentVariable($var, $envvar, "Process")
	}
}


function Set-Environment
{
	if ($poco_base -eq '') { $script:poco_base = Get-Location }

	switch ( $vs )
	{
		140 { }
	default { Add-VSCOMNTOOLS $vs }
	}

	if (-Not $Env:PATH.Contains("$Env:POCO_BASE\bin64;$Env:POCO_BASE\bin;"))
	{ $Env:PATH = "$Env:POCO_BASE\bin64;$Env:POCO_BASE\bin;$Env:PATH" }

	if ($openssl_base -eq '')
	{
		$script:openssl_base = '$poco_base\openssl'
	}

	$Env:OPENSSL_DIR		 = "$openssl_base"
	$Env:OPENSSL_INCLUDE = "$Env:OPENSSL_DIR\include"
	$Env:OPENSSL_LIB		 = "$Env:OPENSSL_DIR\lib;$Env:OPENSSL_DIR\lib\VC"
	Add-Env-Var "OPENSSL" "INCLUDE"
	Add-Env-Var "OPENSSL" "LIB"

	if ($mysql_base -ne '')
	{
		$Env:MYSQL_DIR		 = "$mysql_base"
		$Env:MYSQL_INCLUDE = "$Env:MYSQL_DIR\include"
		$Env:MYSQL_LIB		 = "$Env:MYSQL_DIR\lib"
		Add-Env-Var "MYSQL" "INCLUDE"
		Add-Env-Var "MYSQL" "LIB"
	}

	$vsct = "VS$($vs)COMNTOOLS"
	$vsdir = ''
	$vsdir = (Get-Item Env:$vsct).Value
	$Command = ''
	$CommandArg = ''
	if ($platform -eq 'x64') { $CommandArg = "amd64" }
	else										 { $CommandArg = "x86" }
	if ($vs -eq 150)
	{
		$Command = Resolve-Path "$($vsdir)\..\..\VC\Auxiliary\Build\vcvarsall.bat"
		$script:msbuild_exe = Resolve-Path "$($vsdir)\..\..\MSBuild\15.0\Bin\MSBuild.exe"
	} else {
	if ($vs -eq 160)
	{
		$Command = Resolve-Path "$($vsdir)\..\..\VC\Auxiliary\Build\vcvarsall.bat"
		$script:msbuild_exe = Resolve-Path "$($vsdir)\..\..\MSBuild\Current\Bin\MSBuild.exe"
	}
	else
	{
		if ($vs -eq 170)
		{
			$Command = Resolve-Path "$($vsdir)\..\..\VC\Auxiliary\Build\vcvarsall.bat"
			$script:msbuild_exe = Resolve-Path "$($vsdir)\..\..\MSBuild\Current\Bin\MSBuild.exe"
		}
		else
		{
			$Command = Resolve-Path "$($vsdir)\..\..\VC\vcvarsall.bat"
			$script:msbuild_exe = "MSBuild.exe"
		}
	}}

	$tempFile = [IO.Path]::GetTempFileName()
	cmd /c " `"$Command`" $CommandArg && set > `"$tempFile`" "
	Get-Content $tempFile | Foreach-Object {
		if($_ -match "^(.*?)=(.*)$")
		{
			Set-Content "Env:$($matches[1])" $matches[2]
		}
	}
	Remove-Item $tempFile
}


function Process-Input
{
	if ($help -eq $true)
	{
		Write-Host 'Usage:'
		Write-Host '------'
		Write-Host 'buildwin.ps1 [-poco_base		<dir>]'
		Write-Host '						 [-vs					 140 | 150 | 160 | 170]'
		Write-Host '						 [-action			 build | rebuild | clean]'
		Write-Host '						 [-linkmode		 shared | static_mt | static_md | all]'
		Write-Host '						 [-config			 release | debug | both]'
		Write-Host '						 [-platform		 Win32 | x64 | WinCE | WEC2013]'
		Write-Host '						 [-samples]'
		Write-Host '						 [-tests]'
		Write-Host '						 [-omit				 "Lib1X;LibY;LibZ;..."]'
		Write-Host '						 [-tool				 msbuild | devenv]'
		Write-Host '						 [-useenv			 env | noenv]'
		Write-Host '						 [-verbosity		minimal | quiet | normal | detailed | diagnostic'
		Write-Host '						 [-openssl_base <dir>]'
		Write-Host '						 [-mysql_base	 <dir>]'

		Exit
	}
	else
	{
		Set-Environment

		Write-Host "Build configuration:"
		Write-Host "--------------------"
		Write-Host "Poco Base:		 $poco_base"
		Write-Host "Version:			 $vs"
		Write-Host "Action:				$action"
		Write-Host "Link Mode:		 $linkmode"
		Write-Host "Configuration: $config"
		Write-Host "Platform:			$platform"
		Write-Host "Tests:				 $tests"
		Write-Host "Samples:			 $samples"
		Write-Host "Build Tool:		$tool"

		if ($omit -ne '')
		{
			Write-Host "Omit:					$omit"
		}

		if ($openssl_base -ne '')
		{
			Write-Host "OpenSSL:			 $openssl_base"
		}

		if ($mysql_base -ne '')
		{
			Write-Host "MySQL:				 $mysql_base"
		}

		# NB: this won't work in PowerShell ISE
		#Write-Host "Press Ctrl-C to exit or any other key to continue ..."
		#$x = $host.UI.RawUI.ReadKey("NoEcho,IncludeKeyUp")
	}
}


function Exec-MSBuild([string] $vsProject, [string] $projectConfig)
{
	if (!(Test-Path -Path $vsProject -PathType leaf)) {
		Write-Host "Project $vsProject not found, skipping."
		return
	}

	$cmd = "&`"$script:msbuild_exe`" $vsProject /nologo /m /t:$action /p:Configuration=$projectConfig /p:BuildProjectReferences=false /p:Platform=$platform /p:useenv=$useenv /v:$verbosity"
	Write-Host $cmd
	Invoke-Expression $cmd
	if ($LastExitCode -ne 0) { Exit $LastExitCode }
}


function Build-MSBuild([string] $vsProject, [switch] $skipStatic)
{
	if ($linkmode -contains "static" -and $skipStatic) { Return }

	if ($linkmode -eq 'all')
	{
		$linkModeArr = @('shared')
		if (-not $skipStatic)
		{
			$linkModeArr += 'static_mt', 'static_md'
		}

		foreach ($mode in $linkModeArr)
		{
			if ($config -eq 'both')
			{
				$configArr = 'release', 'debug'
				foreach ($cfg in $configArr)
				{
					Exec-MSBuild $vsProject "$($cfg)_$($mode)"
				}
			}
			else #config
			{
				Exec-MSBuild $vsProject "$($config)_$($mode)"
			}
		}
	}
	else #linkmode
	{
		if ($config -eq 'both')
		{
			$configArr = 'release', 'debug'
			foreach ($cfg in $configArr)
			{
				Exec-MSBuild $vsProject "$($cfg)_$($linkmode)"
			}
		}
		else #config
		{
			Exec-MSBuild $vsProject "$($config)_$($linkmode)"
		}
	}
}


function Exec-Devenv([string] $projectConfig, [string] $vsProject)
{
	$cmd = "devenv /useenv /$action $projectConfig $vsProject"
	Write-Host $cmd
	Invoke-Expression $cmd
}


function Build-Devenv([string] $vsProject, [switch] $skipStatic)
{
	if ($linkmode -contains "static" -and $skipStatic) { Return }

	if ($linkmode -eq 'all')
	{
		$linkModeArr = @('shared')
		if (-not $skipStatic)
		{
			$linkModeArr += 'static_mt', 'static_md'
		}

		foreach ($mode in $linkModeArr)
		{
			if ($config -eq 'both')
			{
				$configArr = 'release', 'debug'
				foreach ($cfg in $configArr)
				{
					Exec-Devenv "$($cfg)_$($mode)" $vsProject
				}
			}
			else #config
			{
				Exec-Devenv "$($config)_$($mode)" $vsProject
			}
		}
	}
	else #linkmode
	{
		if ($config -eq 'both')
		{
			$configArr = 'release', 'debug'
			foreach ($cfg in $configArr)
			{
				Exec-Devenv "$($cfg)_$($linkmode)" $vsProject
			}
		}
		else #config
		{
			Exec-Devenv "$($config)_$($linkmode)" $vsProject
		}
	}
}


function Build-samples
{
	process {
		$sampleName = $_.BaseName.split("_")[0]
		$sampleProjName = "$($poco_base)\$($componentDir)\samples\$($sampleName)\$($_)"
		if ($tool -eq 'devenv') { Build-Devenv $sampleProjName }
		elseif ($tool -eq 'msbuild') { Build-MSBuild $sampleProjName }
		else{ Write-Host "Tool not supported: $tool" }
	}
}


function Build-Exec([string] $tool, [string] $vsProject, [switch] $skipStatic)
{
	 if (!(Test-Path -Path $vsProject)) # not found
	 {
			Write-Host "+------------------------------------------------------------------"
			Write-Host "| VS project $vsProject not found, skipping."
			Write-Host "+------------------------------------------------------------------"
			Return
	 }
	 if		 ($tool -eq 'devenv')	{ Build-Devenv $vsProject -skipStatic:$skipStatic }
	 elseif ($tool -eq 'msbuild') { Build-MSBuild $vsProject -skipStatic:$skipStatic }
	 else
	 {
			Write-Host "Build tool $tool not supported. Exiting."
			Exit -1
	 }
}


function Build-Components([string] $extension, [string] $platformName, [string] $type)
{

	Get-Content "$poco_base\components" | Foreach-Object {

		$component = $_
		$componentDir = $_.Replace("/", "\")
		$componentArr = $_.split('/')
		$componentName = $componentArr[$componentArr.Length - 1]
		$suffix = "_vs$vs"

		$omitArray = @()
		$omit.Split(',;') | ForEach {
				$omitArray += $_.Trim()
		}

		if ($omitArray -NotContains $component)
		{
			$vsProject = "$poco_base\$componentDir\$componentName$($platformName)$($suffix).$($extension)"

			if (!(Test-Path -Path $vsProject)) # when VS project name is not same as directory name
			{
				$vsProject = "$poco_base\$componentDir$($platformName)$($suffix).$($extension)"
				if (!(Test-Path -Path $vsProject)) # not found
				{
					Write-Host "+------------------------------------------------------------------"
					Write-Host "| VS project $vsProject not found, skipping."
					Write-Host "+------------------------------------------------------------------"
					Return # since Foreach-Object is a function, this is actually loop "continue"
				}
			}

			Write-Host "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
			Write-Host "| Building $vsProject"
			Write-Host "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"

			if ($type -eq "lib")
			{
				Build-Exec $tool $vsProject
			}
			ElseIf ($tests -and ($type -eq "test"))
			{
				$vsTestProject = "$poco_base\$componentDir\testsuite\TestSuite$($platformName)$($suffix).$($extension)"
				Write-Host "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
				Write-Host "| Building $vsTestProject"
				Write-Host "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
				Build-Exec $tool $vsTestProject

				if ($component -eq "Foundation") # special case for Foundation, which needs test app and dll
				{
					$vsTestProject = "$poco_base\$componentDir\testsuite\TestApp$($platformName)$($suffix).$($extension)"
					Write-Host "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
					Write-Host "| Building $vsTestProject"
					Write-Host "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
					Build-Exec $tool $vsTestProject

					$vsTestProject = "$poco_base\$componentDir\testsuite\TestLibrary$($platformName)$($suffix).$($extension)"
					Write-Host "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
					Write-Host "| Building $vsTestProject"
					Write-Host "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
					Build-Exec $tool $vsTestProject -skipStatic
				}
			}
			ElseIf ($samples -and ($type -eq "sample"))
			{
				if ($platform -eq 'x64')
				{
					Get-Childitem "$poco_base\$($componentDir)" -Recurse |`
						Where {$_.Extension -Match $extension -And $_.DirectoryName -Like "*samples*" -And $_.BaseName -Like "*$platformName$($suffix)" } `
						| Build-samples "$_"
				}
				else
				{
					Get-Childitem "$poco_base\$($componentDir)" -Recurse |`
						Where {$_.Extension -Match $extension -And $_.DirectoryName -Like "*samples*" -And $_.BaseName -Like "*$($suffix)" -And $_.BaseName -NotLike "*_x64_*" } `
						| Build-samples "$_"
				}
			}
		}
		else
		{
			Write-Host "-------------------------------"
			Write-Host "# Skipping $componentDir"
			Write-Host "-------------------------------"
		}
	}
}


function Build
{
	Process-Input

	if ($vs -lt 100) { $extension = 'vcproj'	}
	else										 { $extension = 'vcxproj' }

	$platformName = ''
	if ($platform -eq 'x64')			 { $platformName = '_x64' }
	elseif ($platform -eq 'WinCE') { $platformName = '_CE' }

	Build-Components $extension $platformName "lib"
	Build-Components $extension $platformName "test"
	Build-Components $extension $platformName "sample"
}


Build
